package com.xx.util;

import cn.hutool.core.util.ReflectUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Objects;

public class PropertyTypesUtil {

    final static String PKG_NAME = "com.xx";

    /**
     * 解析类的参数列表
     *
     * @param clazz
     * @return
     */
    public static JSONArray parsePropertyTypes(Class clazz) {
        JSONArray allInput = new JSONArray();
        getPropertyTypes(clazz, allInput, null, null);
        return allInput;
    }

    /**
     * 递归获取类的属性类型
     */
    public static void getPropertyTypes(Class<?> clazz, JSONArray allInput, String parentFieldName, String parentPath) {
        // 获取当前类的所有属性
        Field[] fields = ReflectUtil.getFields(clazz);
        for (Field field : fields) {
            // 获取属性名称和类型
            String propertyName = field.getName();
            Class<?> propertyType = field.getType();
            String path = (Objects.isNull(parentPath) ? "" : parentPath + ".") + propertyName;

            if (!Objects.equals("serialVersionUID", propertyName)) {
                // 存储属性类型信息
                JSONObject obj = new JSONObject();
                obj.put("code", propertyName);
                obj.put("parentCode", parentFieldName);
                obj.put("type", propertyType.getName().startsWith(PKG_NAME) ? "object" : propertyType.getSimpleName());
                obj.put("must", "0");
                obj.put("path", path);
                allInput.add(obj);
            }

            // 如果是集合，还需要把泛型解析出来
            if (List.class.isAssignableFrom(propertyType)) {
                Type genericType = field.getGenericType();
                if (genericType instanceof ParameterizedType) {
                    ParameterizedType pt = (ParameterizedType) genericType;
                    Type[] actualTypeArguments = pt.getActualTypeArguments();
                    if (actualTypeArguments.length > 0) {
                        Type actualTypeArgument = actualTypeArguments[0];
                        try {
                            getPropertyTypes(Class.forName(actualTypeArguments[0].getTypeName()), allInput, propertyName, path + "[]");
                        } catch (Exception e) {
                            //log.error("解析：{}异常", actualTypeArgument.toString());
                        }
                    }
                }
            }

            // 如果属性类型是一个类（而不是基本类型），则递归获取这个类的属性类型
            if (!propertyType.isPrimitive() && propertyType.getName().startsWith(PKG_NAME)) {
                getPropertyTypes(propertyType, allInput, propertyName, path);
            }
        }

        // 获取父类的属性类型
        if (clazz.getSuperclass() != null && !clazz.getSuperclass().equals(Object.class)) {
            getPropertyTypes(clazz.getSuperclass(), allInput, null, null);
        }
    }
}
